﻿/* 数组操作扩展类
 */

/* 未完事项
 * 1、泛型函数的单元测试。
 */
namespace LSLib.Collections
{
    using System;

    public static class ArrayEx
    {
        #region MergerArray(合并数组)
        /// <summary>合并数组(泛型）
        /// </summary>
        /// <param name="arrFirst">第一个数组</param>
        /// <param name="arrSecond">第二个数组</param>
        /// <returns>合并后的数组(第一个数组+第二个数组，长度为两个数组的长度)</returns>
        public static T[] MergerArray<T>(T[] arrFirst, T[] arrSecond)
        {
            if (arrFirst == null) throw new ArgumentNullException("arrFirst");
            if (arrSecond == null) throw new ArgumentNullException("arrSecond");

            T[] result = new T[arrFirst.Length + arrSecond.Length];
            arrFirst.CopyTo(result, 0);
            arrSecond.CopyTo(result, arrFirst.Length);
            return result;
        }

        /// <summary>合并数组(string)
        /// </summary>
        /// <param name="arrFirst">第一个数组</param>
        /// <param name="arrSecond">第二个数组</param>
        /// <returns>合并后的数组(第一个数组+第二个数组，长度为两个数组的长度)</returns>
        public static string[] MergerArray(string[] arrFirst, string[] arrSecond)
        {
            return MergerArray<string>(arrFirst, arrSecond);
        }
        #endregion

        #region AppendArray(数组追加)
        /// <summary>数组追加（泛型）
        /// </summary>
        /// <param name="arrSource">原数组</param>
        /// <param name="str">字符串</param>
        /// <returns>合并后的数组(数组+字符串)</returns>
        public static T[] AppendArray<T>(T[] arrSource, T str)
        {
            if (arrSource == null) throw new ArgumentNullException("arrSource");

            T[] result = new T[arrSource.Length + 1];
            arrSource.CopyTo(result, 0);
            result[arrSource.Length] = str;
            return result;
        }

        /// <summary>数组追加(string)
        /// </summary>
        /// <param name="arrSource">原数组</param>
        /// <param name="str">字符串</param>
        /// <returns>合并后的数组(数组+字符串)</returns>
        public static string[] AppendArray(string[] arrSource, string str)
        {
            return AppendArray<string>(arrSource, str);
        }
        #endregion

        #region SplitArray（从数组中截取一部分成新的数组）
        /// <summary>从数组中截取一部分成新的数组（泛型）
        /// </summary>
        /// <param name="arrSource">原数组</param>
        /// <param name="StartIndex">原数组的起始位置</param>
        /// <param name="EndIndex">原数组的截止位置</param>
        /// <returns>返回从起始位置到截止位置组成的新数组</returns>
        public static T[] SplitArray<T>(T[] arrSource, int StartIndex, int EndIndex)
        {
            if (arrSource == null) throw new ArgumentNullException("arrSource");
            else if (StartIndex < 0 || StartIndex >= arrSource.Length) throw new ArgumentOutOfRangeException("StartIndex", StartIndex, "参数 StartIndex 必须小于 arrSource 的长度，且必须为非负值。");
            else if (EndIndex < 0 || EndIndex >= arrSource.Length) throw new ArgumentOutOfRangeException("EndIndex", EndIndex, "参数 EndIndex 必须小于 arrSource 的长度，且必须为非负值。");
            else if (StartIndex > EndIndex) throw new ArgumentException("参数 StartIndex 必须小于或等于 EndIndex。");

            T[] result = new T[EndIndex - StartIndex + 1];
            for (int i = 0; i <= EndIndex - StartIndex; i++)
            {
                result[i] = arrSource[i + StartIndex];
            }
            return result;
        }

        /// <summary>从数组中截取一部分成新的数组(string)
        /// </summary>
        /// <param name="arrSource">原数组</param>
        /// <param name="StartIndex">原数组的起始位置</param>
        /// <param name="EndIndex">原数组的截止位置</param>
        /// <returns>返回从起始位置到截止位置组成的新数组</returns>
        public static string[] SplitArray(string[] arrSource, int StartIndex, int EndIndex)
        {
            return SplitArray<string>(arrSource, StartIndex, EndIndex);
        }
        #endregion

        #region ReverseArray（翻转数组）
        /// <summary>翻转数组（泛型）
        /// </summary>
        /// <param name="arrSource">原数组</param>
        /// <returns>翻转后的数组</returns>
        public static T[] ReverseArray<T>(T[] arrSource)
        {
            if (arrSource == null) throw new ArgumentNullException("arrSource");

            T[] result = new T[arrSource.Length];
            for (int i = 0; i < arrSource.Length; i++)
            {
                result[i] = arrSource[arrSource.Length - 1 - i];
            }
            return result;
        }

        /// <summary>翻转数组(byte)
        /// </summary>
        /// <param name="arrSource">原数组</param>
        /// <returns>翻转后的数组</returns>
        public static byte[] ReverseArray(byte[] arrSource)
        {
            return ReverseArray<byte>(arrSource);
        }
        #endregion

    }
}
